/**
 *@file tipos.c
 *@brief O arquivo tipos.c contém a definição dos tipos criados
 * para o projeto.
 *
 *@details Os tipos criados pelo projeto devem todos ficar nesse
 * arquivo para evitar que sejam criados dois tipos para o mesmo
 * propóstio, pois, ficando todos os tipos no mesmo arquivo,
 * será fácil e rápido identificar esse problema.
 *
 */

/**
 *@addtogroup tipos
 *@{
 */

/**
 *@typedef Tile_t
 *@brief Cada célula do mapa
 *
 *@details Deve ser signed e precisa pelo menos
 * ser um int8.
 *
 */
#ifdef SAFE_MODE
typedef short int Tile_t;
#else
typedef int_least8_t Tile_t;
#endif

/**
 *@enum Dir_t
 *@brief Dir_t armazena a direção.
 *
 *@details Dir_t armazena a direção/sentido absoluta de um objeto.
 *\n
 * Pode ser norte, leste, sul, oeste ou indefinido.
 * É interssante inicializar a direção com indefinido para evitar
 * erros.
 *\n
 * Se a direção NÃO for indefinida, você pode achar os comandos
 * abaixo bem úteis
 *\n
 *@code
 * if(dir&1){ printf("a direção é horizontal\n"); }
 * if(dir&2){ printf("a direção é vertical\n"); }
 * @endcode
 *
 *@see Anima anim
 */
enum Dir_t {indefinido = -1,/**< Usado geralmente durante a inicialização e para indicar que um Anima não se moverá ou que a direção é desconhecida */
norte = 0,/**< Indica a direção norte */
leste = 1,/**< Indica a direção leste */
sul = 2,/**< Indica a direção sul */
oeste = 3/**< Indica a direção oeste */};

/**
 *@struct Anima
 *@brief Estrutura que armazena informações sobre os cozinheiros e o gato
 *
 *@details Estrutura que armazena informações relativas a posição no mapa
 * sobre os personagens.
 * Deve ser muito útil para as funções que fazem a animação, as funções
 * pathfinder e talvez a ligação que ocorre entre os dois subssistemas,
 * feita pelo sistema de eventos.
 *
 *@see Dir_t
 */
struct Anima{
 /**
  *@{
  */
 struct Anima * anterior;
 uint_least16_t x;/**< A cordenada do personagem em relação ao eixo x (0~799) */
 uint_least8_t x_fake;/**< A cordenada do personagem em relação ao eixo x do mapa (0~24) */
 uint_least16_t y;/**< A cordenada do personagem em relação ao eixo y (0~639) */
 uint_least8_t y_fake;/**< A cordenada do personagem em relação ao eixo y do mapa (0~19) */
 enum Dir_t dir;/**< Informa a direção do Anima */
 Tile_t tile;/**< Valor que representa o tile que será usado para desenhar o Anima. O valor pode ser 18 (gato do ic) ou maior que 18 (cozinheiros). Precisa ser um int8 no mínimo, e é recomendável que seja. */
 struct Anima * proximo;
 /**
  *@}
  */
};

/**
 *@struct Posicao_t
 *@brief Estrutura que armazena uma posição no mapa
 *
 *@details Estrutura que é usada para armazenar
 * uma coordenada no mapa. Necessária para o
 * path finder e o maze generator.
 *
 */
struct Posicao_t {
 /**
  *@{
  */
 uint_least8_t x;/**< A cordenada em relação ao eixo x */
 uint_least8_t y;/**< A cordenada em relação ao eixo y */
 /**
  *@}
  */
};

/**
 *@typedef Prato_t
 *@brief Elemento manipulado pelo módulo de pilhas
 *
 *@details O módulo de pilhas criado para o jogo
 * trabalha com pilhas de elementos do tipo Prato_t.
 * Se for necessário mudar o tipo de elemento que o
 * módulo de pilhas deverá utilizar é só modificar
 * esse typedef.
 *
 */
typedef struct Posicao_t Prato_t;

/**
 *@typedef Pilha_id
 *@brief O tipo usado para criar uma pilha
 *
 *@details Variáveis do tipo Pilha_id armazenam
 * um inteiro que que representa a pilha a ser
 * manipulada. Toda pilha tem um número positivo
 * inteiro que a identifica.
 *\n
 * O motivo de Pilha_id poder armazenar números
 * negativos quando na verdade as pilhas só
 * são representadas por números positivos é
 * que a variável do tipo Pilha_id pode não
 * estar apontando para uma pilha e, nesse caso,
 * ela guarda um valor negativo.
 *\n
 * Exemplo de código
 *@code
 * Pilha_id minha_pilha = nova_pilha();
 * if(minha_pilha < 0){
 *  printf("Pilha não podê ser criada\n");
 * }
 * @endcode
 *
 *@see nova_pilha
 *
 */
typedef short int Pilha_id;

/**
 *@typedef Tamanho_t
 *@brief Armazena o tamanho de uma pilha
 *
 *@details Cada pilha tem um tamanho não-fixo e o
 * tamanho das pilhas armazenados no módulo de
 * pilhas são variáveis do tipo Tamanho_t. Não é
 * necessário declarar variáveis do tipo Tamanho_t
 * fora do módulo de pilhas, pois elas só são usadas
 * internamente no módulo de pilhas.
 *\n
 * Se quiser armazenar o tamanho de uma pilha fora
 * do módulo de pilhas use o tipo STamanho_t.
 *
 *@see STamanho_t
 *
 */
typedef unsigned int Tamanho_t;

/**
 *@typedef STamanho_t
 *@brief Armazena o tamanho de uma pilha
 *
 *@details STamanho_t tem as mesmas características
 * de Tamanho_t, porém ela é útil mesmo fora do
 * módulo de pilhas. Quando a pilha existe e não
 * está vazia, a variável do tipo STamanho_t
 * armazena um número natural não-nulo, quando a
 * pilhas existe e está vazia ela armazena 0 e
 * quando a pilha não existe ela armazena um número
 * negativo.
 *\n
 *@code
 * STamanho_t tam_pilha = ver_tam_pilha(minha_pilha);
 * if(tam_pilha > 0){
 *  printf("Pilha existe e armazena elementos\n");
 * }else if(tam_pilha == 0){
 *  printf("Pilha existe e está vazia\n");
 * }else if(tam_pilha < 0){
 *  printf("Pilha não existe\n");
 * }
 * @endcode
 *\n
 * STamanho_t deve ser de um tipo que possa armazenar
 * todos os valores que Tamanho_t pode conter e ainda
 * poder armazenar pelo menos um valor negativo.
 *
 *@see Tamanho_t ver_tam_pilha
 *
 */
typedef long int STamanho_t;

/**
 *@}
 */
